package com.xxxt.hrs.controller;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageInfo;
import com.xxxt.dao.CollegeMapper;
import com.xxxt.dao.CompanyMapper;
import com.xxxt.dao.GradeMapper;
import com.xxxt.dao.SchoolMapper;
import com.xxxt.dao.SpecialtyMapper;
import com.xxxt.dao.StudentMapper;
import com.xxxt.entity.ClassGrade;
import com.xxxt.entity.College;
import com.xxxt.entity.Company;
import com.xxxt.entity.Grade;
import com.xxxt.entity.School;
import com.xxxt.entity.Specialty;
import com.xxxt.entity.Student;
import com.xxxt.entity.Teacher;
import com.xxxt.hrs.service.StudentService;
import com.xxxt.hrs.service.impl.ImportStudentService;
import com.xxxt.utils.ExportExcelUtil;
import com.xxxt.utils.FileDownUtil;
import com.xxxt.utils.FileUploadUtil;
import com.xxxt.utils.MD5Util;
import com.xxxt.utils.MailUtil;
import com.xxxt.utils.PropertyCheckUtil;

@Controller
@RequestMapping("/student")
public class StudentController {
	@Autowired
	private StudentService studentService;
	@Autowired
	private StudentMapper studentMapper;
	@Autowired
	private GradeMapper gradeMapper;
	@Autowired
	private SpecialtyMapper specialtyMapper;
	@Autowired
	private CollegeMapper collegeMapper;
	@Autowired
	private SchoolMapper schoolMapper;
	@Autowired
	private ImportStudentService importStudentService;
	@Autowired
	private CompanyMapper companyMapper;

	/**
	 * @describe 教师增加单个学生信息
	 * @param sno           学生学号
	 * @param name          学生姓名
	 * @param phone         学生手机号
	 * @param email         学生邮箱
	 * @param classGradeId  老师选择学生所在班级id
	 * @param idcard        学生身份证号
	 * @param tno           当前老师工号
	 * @param liveSituation 学生住宿情况
	 * @param birthPlace    学生籍贯
	 * @return
	 * @throws Exception
	 */

	@RequestMapping(value = "/addOneStudent", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject addOneStudent(String sno, String name, String classGradeId, String tno) throws Exception {
		JSONObject json = new JSONObject();
		if (sno == null || "".equals(sno) || name == null || "".equals(name) || classGradeId == null
				|| "".equals(classGradeId) || tno == null || "".equals(tno)) {
			json.put("status", 3);
			json.put("message", "传入字段不合法!");
			return json;
		}
		// 校验名字格式
		boolean checkname = MailUtil.checkname(name);
		if (checkname == false) {
			json.put("status", 4);
			json.put("message", "名字格式不正确!");
			return json;
		}
		String passwordAndKey = MD5Util.md5withkey("123456", "xxxt");
		Teacher teacher = new Teacher(tno);
		ClassGrade classGrade = new ClassGrade(classGradeId);
		Student student = new Student(sno, passwordAndKey, name, classGrade, teacher);
		boolean addOneStudent;
		try {
			addOneStudent = studentService.addOneStudent(student);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		if (!addOneStudent) {
			json.put("status", 1);
			json.put("message", "增加失败,这名学生已经存在!");
			return json;
		}
		json.put("status", 0);
		json.put("message", "增加成功!");
		return json;
	}

	/**
	 * @describe 老师上传表格文件批量导入学生
	 * @param excelFile    老师上传的学生表格文件
	 * @param tno          当前登录的老师id
	 * @param classGradeId 老师选择班级的id
	 * @param gradeId      年级id
	 * @param classGrade   班级名称
	 * @return
	 * @throws Exception
	 */
	@RequestMapping(value = "/batchAddStudent", method = RequestMethod.POST)
	@ResponseBody
	public JSONObject batchAddStudent(MultipartFile excelFile, String tno, String classGradeId, String gradeId,
			String classGrade, HttpServletRequest request, HttpServletResponse response) throws Exception {
		JSONObject json = new JSONObject();
		// 文件判空
		if (excelFile == null) {
			json.put("status", 1);
			json.put("message", "传入文件为空!");
			return json;
		}
		// 文件格式判断
		boolean uploadExcel = FileUploadUtil
				.uploadExcel(FileUploadUtil.getFileNameEnds(excelFile.getOriginalFilename()));
		if (uploadExcel == false) {
			json.put("status", 2);
			json.put("message", "不支持该类型的文件，请上传表格文件!");
			return json;
		}
		// 利用工具类导入Excel表格得到需要导入的学生List集合
		long start = System.currentTimeMillis();
		Map<String, Object> importStudentByExcel = importStudentService.ImportStudentByExcel(excelFile, request,
				response, tno, classGradeId);
		if ((Integer) importStudentByExcel.get("aa") != null) {
			if ((Integer) importStudentByExcel.get("aa") == 1) {
				json.put("status", 1);
				json.put("message", "学生表格为空!");
				return json;
			}
			if ((Integer) importStudentByExcel.get("aa") == 2) {
				json.put("status", 3);
				json.put("message", "表头格式不正确!表头应为:学校,学院,专业,班级,学号,姓名");
				return json;
			}
			if ((Integer) importStudentByExcel.get("aa") == 3) {
				json.put("status", -1);
				json.put("message", "学生数据全部不正确!");
				return json;
			}
			if ((Integer) importStudentByExcel.get("aa") == 4) {
				json.put("status", -1);
				json.put("message", "服务器内部错误!");
				return json;
			}
		}
		// 获取表格总数据数量(不可能为null)
		Integer zonggong = (Integer) importStudentByExcel.get("zonggong");
		// 获取表格重复人数(可能为null)
		Integer excelchongfu = (Integer) importStudentByExcel.get("excelchongfu");
		// 获取数据库重复人数(可能为null)
		Integer dbchongfu = (Integer) importStudentByExcel.get("dbchongfu");
		// 获取成功人数(不可能为null)
		Integer chenggong = (Integer) importStudentByExcel.get("chenggong");
		// 获取检验不合格人数(可能为null)
		Integer buhege = (Integer) importStudentByExcel.get("buhege");
		// 获取数据不完整人数
		Integer buwanzheng = (Integer) importStudentByExcel.get("buwanzheng");
		json.put("status", 0);
		json.put("message", "导入成功！读取到表格中数据共" + zonggong + "条，其中表格重复数据" + excelchongfu + "条，与数据库中数据重复数据共" + dbchongfu
				+ "条，数据格式不合格数据" + buhege + "条，数据不完整的数据" + buwanzheng + "条，最终导入数据" + chenggong + "条");
		long end = System.currentTimeMillis();
		System.out.println("耗时" + (end - start) + "ms");
		return json;
	}

	/**
	 * @describe 学生修改个人信息
	 * @param sno           学生学号
	 * @param phone         学生手机号
	 * @param email         学生邮箱
	 * @param idcard        学生身份证
	 * @param liveSituation 学生住宿情况
	 * @param birthPlace    学生籍贯
	 * @return
	 */
	@RequestMapping(value = "/modifyStudentInfo", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject modifyStudentInfo(String name, String sno, String phone, String sex, String email, String idcard,
			String liveSituation, String province, String city, String area) {
		JSONObject json = new JSONObject();
		// 校验数据正确性
		if (sno == null || "".equals(sno) || phone == null || "".equals(phone) || sex == null || "".equals(sex)
				|| email == null || "".equals(email) || idcard == null || "".equals(idcard) || liveSituation == null
				|| "".equals(liveSituation) || province == null || "".equals(province) || city == null
				|| "".equals(city) || area == null || "".equals(area)) {
			json.put("status", 1);
			json.put("message", "传入字段不合法！");
			return json;
		}
		// 数据校验：
		// 校验身份证
		boolean idCard2 = PropertyCheckUtil.isIdCard(idcard);
		if (idCard2 == false) {
			json.put("status", 3);
			json.put("message", "身份证格式不正确！");
			return json;
		}
		// 校验手机号
		boolean phone2 = PropertyCheckUtil.isPhone(phone);
		if (phone2 == false) {
			json.put("status", 4);
			json.put("message", "手机格式不正确！");
			return json;
		}
		// 校验邮箱
		boolean checkemail = MailUtil.checkemail(email);
		if (checkemail == false) {
			json.put("status", 5);
			json.put("message", "邮箱格式不正确！");
			return json;
		}
		// 校验姓名
		boolean name2 = MailUtil.checkname(name);
		if (name2 == false) {
			json.put("status", 6);
			json.put("message", "姓名格式不正确！");
			return json;
		}
		// 校验学生是否存在
		// 拼接地址
		String birthPlace = province + "," + city + "," + area;
		Student student = new Student(sno, phone, sex, email, idcard, liveSituation, birthPlace);
		student.setName(name);
		Student queryOneStudentBySno;
		try {
			queryOneStudentBySno = studentMapper.queryOneStudentBySno(sno);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		if (queryOneStudentBySno == null) {
			json.put("status", 2);
			json.put("message", "修改信息失败，学生不存在！");
			return json;
		}
		try {
			// 进行修改
			studentMapper.updateStudentBySno(student);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		json.put("status", 0);
		json.put("message", "修改成功！");
		return json;
	}

	/**
	 * @describe 根据前端传来的字符串数组批量删除学生
	 * @param snoArray 前端传入需要删除的学生学号数组
	 * @return
	 */
	@RequestMapping(value = "/batchDeleteStudent", method = RequestMethod.POST)
	@ResponseBody
	public JSONObject batchDeleteStudent(@RequestParam("snoArray[]") List<String> snoArray) {
		JSONObject json = new JSONObject();
		if (snoArray == null || snoArray.size() == 0) {
			json.put("status", 1);
			json.put("message", "传入数据不合法！");
			return json;
		}
		try {
			studentMapper.batchDeleteStudent(snoArray);
		} catch (Exception e) {
			json.put("status", 2);
			json.put("message", "批量删除学生失败！");
			return json;
		}
		json.put("status", 0);
		json.put("message", "批量删除学生成功");
		return json;

	}

	/**
	 * @describe 根据学号删除一个学生
	 * @param sno 需要删除的学生学号
	 * @return
	 */
	@RequestMapping(value = "/deleteOneStudent", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject deleteOneStudent(String sno) {
		JSONObject json = new JSONObject();
		if (sno == null || "".equals(sno)) {
			json.put("status", 1);
			json.put("message", "传入数据不合法！");
			return json;
		}
		// 查询对应的学生记录
		Student student;
		try {
			student = studentMapper.queryOneStudentBySno(sno);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		if (student == null) {
			json.put("status", 2);
			json.put("message", "学生不存在，删除失败！");
			return json;
		}
		try {
			studentMapper.deleteStudent(sno);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		json.put("status", 0);
		json.put("message", "删除成功！");
		return json;
	}

	/**
	 * @describe 根据学号查询单个学生
	 * @param sno 需要查询的学生学号
	 * @return
	 */
	@RequestMapping(value = "/queryOneStudentBySno", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryOneStudentBySno(String sno) {
		JSONObject json = new JSONObject();
		// 检查数据合法性
		if (sno == null || "".equals(sno)) {
			json.put("status", 1);
			json.put("message", "传入数据不合法！");
			return json;
		}
		// 先查询此人是否存在
		boolean studentIsExist;
		try {
			studentIsExist = studentService.studentIsExist(sno);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		if (studentIsExist == false) {
			json.put("status", 2);
			json.put("message", "此学生不存在！");
			return json;
		}
		// 进行查询
		Student queryOneStudentSchoolInfoBySno;
		try {
			queryOneStudentSchoolInfoBySno = studentMapper.queryOneStudentSchoolInfoBySno(sno);
			System.out.println(queryOneStudentSchoolInfoBySno);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		json.put("status", 0);
		json.put("message", "操作成功");
		json.put("student", queryOneStudentSchoolInfoBySno);
		return json;
	}

	/**
	 * 
	 * 1.姓名有，其他空 根据姓名查学生
	 * 
	 * 2.班级有，姓名有：根据姓名查该班级的学生 3.班级有，姓名无：根据班级id查这个班级学生
	 * 
	 * 4.年级有，姓名有：根据姓名模糊查询该年级的学生 5.年级有，姓名无：根据年级id查询这个班级的学生
	 * 
	 * 6.专业有，姓名有：根据姓名查询该专业的学生 7,专业有，姓名无：根据专业id查询所有学生
	 * 
	 * 8.学院有，姓名有：根据姓名查询该需学院的学生 9.学院有，姓名无：根据学院id查询该学院学生
	 * 
	 * 10.学校有，姓名有：根据姓名查询该学校的学生 11.学校有，姓名无：根据学校id查询该学校学生
	 * 
	 * @param name         姓名
	 * @param classGradeId 班级id
	 * @param gradeId      年级id
	 * @param specialtyId  专业id
	 * @param collegeId    年级id
	 * @param schoolId     学校id
	 * @param pageSize     一页大小
	 * @param pageNum      从第几条开始
	 * @return
	 */
	@RequestMapping(value = "/queryManyStudentWithFactors", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryManyStudentWithFactors(String name, String classGradeId, String gradeId, String specialtyId,
			String collegeId, String schoolId, Integer pageSize, Integer pageNum) {
		JSONObject json = new JSONObject();
		System.out.println(pageNum);
		System.out.println(pageSize);
		// 条件判断（不能都为空）：
		if ((name == null || "".equals(name)) && (classGradeId == null || "".equals(classGradeId))
				&& (gradeId == null || "".equals(gradeId)) && (specialtyId == null || "".equals(specialtyId))
				&& (collegeId == null || "".equals(collegeId)) && (schoolId == null || "".equals(schoolId))
				&& (pageSize == null) && (pageNum == null)) {
			json.put("status", 1);
			json.put("message", "传入数据不合法！");
			return json;
		}
		if ("".equals(name) || "".equals(classGradeId) || "".equals(gradeId) || "".equals(specialtyId)
				|| "".equals(collegeId) || "".equals(schoolId) || pageSize == null || pageNum == null) {
			json.put("status", 1);
			json.put("message", "传入数据不合法！");
			return json;
		}
		// 除了名字，都为空——>根据名字查
		if (name != null && classGradeId == null && gradeId == null && specialtyId == null && collegeId == null
				&& schoolId == null) {
			// 根据名字进行模糊查询
			PageInfo<Student> queryManyStudentByNameLikeWithPage;
			try {
				queryManyStudentByNameLikeWithPage = studentService.queryManyStudentByNameLikeWithPage(pageNum,
						pageSize, name);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryManyStudentByNameLikeWithPage.getSize() <= 0) {
				// 根据名字查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryManyStudentByNameLikeWithPage);
			return json;
		}
		// 姓名加班级(班级id和姓名不为空其他都为空)
		if ((name != null && classGradeId != null)
				&& (gradeId == null && specialtyId == null && collegeId == null && schoolId == null)) {
			PageInfo<Student> queryStudentByNameAndClassGradeWithPage;
			try {
				queryStudentByNameAndClassGradeWithPage = studentService
						.queryStudentByNameAndClassGradeWithPage(pageNum, pageSize, name, classGradeId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentByNameAndClassGradeWithPage.getSize() <= 0) {
				// 根据名字和班级id查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentByNameAndClassGradeWithPage);
			return json;
		}
		// 只班级id查询该班级学生
		if ((classGradeId != null)
				&& (name == null && gradeId == null && specialtyId == null && collegeId == null && schoolId == null)) {
			PageInfo<Student> queryClassGradeByClassGradeIdWithPage;
			try {
				queryClassGradeByClassGradeIdWithPage = studentService.queryClassGradeByClassGradeIdWithPage(pageNum,
						pageSize, classGradeId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryClassGradeByClassGradeIdWithPage.getSize() <= 0) {
				// 根据班级id查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryClassGradeByClassGradeIdWithPage);
			return json;
		}
		// 姓名加年级
		if ((name != null && gradeId != null)
				&& (classGradeId == null && specialtyId == null && collegeId == null && schoolId == null)) {
			PageInfo<Student> queryStudentByNameAndGradeWithPage;
			try {
				queryStudentByNameAndGradeWithPage = studentService.queryStudentByNameAndGradeWithPage(pageNum,
						pageSize, name, gradeId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentByNameAndGradeWithPage.getSize() <= 0) {
				// 根据年级id和姓名查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentByNameAndGradeWithPage);
			return json;
		}
		// 仅年级查询
		if ((gradeId != null) && (name == null && classGradeId == null && specialtyId == null && collegeId == null
				&& schoolId == null)) {
			PageInfo<Student> queryStudentByGradeWithPage;
			try {
				queryStudentByGradeWithPage = studentService.queryStudentByGradeWithPage(pageNum, pageSize, gradeId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentByGradeWithPage.getSize() <= 0) {
				// 根据年级id查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentByGradeWithPage);
			return json;
		}
		// 姓名加专业
		if ((name != null && specialtyId != null)
				&& (gradeId == null && classGradeId == null && collegeId == null && schoolId == null)) {
			PageInfo<Student> queryStudentByNameAndSpecialtyWithPage;
			try {
				queryStudentByNameAndSpecialtyWithPage = studentService.queryStudentByNameAndSpecialtyWithPage(pageNum,
						pageSize, name, specialtyId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentByNameAndSpecialtyWithPage.getSize() <= 0) {
				// 根据专业id和名字查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentByNameAndSpecialtyWithPage);
			return json;
		}
		// 仅专业
		if ((specialtyId != null)
				&& (name == null && gradeId == null && classGradeId == null && collegeId == null && schoolId == null)) {
			PageInfo<Student> queryStudentBySpecialtyWithPage;
			try {
				queryStudentBySpecialtyWithPage = studentService.queryStudentBySpecialtyWithPage(pageNum, pageSize,
						specialtyId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentBySpecialtyWithPage.getSize() <= 0) {
				// 根据专业id查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentBySpecialtyWithPage);
			return json;
		}
		// 姓名加学院
		if ((name != null && collegeId != null)
				&& (gradeId == null && specialtyId == null && classGradeId == null && schoolId == null)) {
			PageInfo<Student> queryStudentByNameAndCollegeWithPage;
			try {
				queryStudentByNameAndCollegeWithPage = studentService.queryStudentByNameAndCollegeWithPage(pageNum,
						pageSize, name, collegeId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentByNameAndCollegeWithPage.getSize() <= 0) {
				// 根据学院id和姓名查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentByNameAndCollegeWithPage);
			return json;
		}
		// 仅学院
		if ((collegeId != null) && (name == null && gradeId == null && specialtyId == null && classGradeId == null
				&& schoolId == null)) {
			PageInfo<Student> queryStudentByCollegeWithPage;
			try {
				queryStudentByCollegeWithPage = studentService.queryStudentByCollegeWithPage(pageNum, pageSize,
						collegeId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentByCollegeWithPage.getSize() <= 0) {
				// 根据学院id查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentByCollegeWithPage);
			return json;
		}
		// 姓名加学校
		if ((name != null && schoolId != null)
				&& (gradeId == null && specialtyId == null && classGradeId == null && collegeId == null)) {
			PageInfo<Student> queryStudentByNameAndSchoolWithPage;
			try {
				queryStudentByNameAndSchoolWithPage = studentService.queryStudentByNameAndSchoolWithPage(pageNum,
						pageSize, name, schoolId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentByNameAndSchoolWithPage.getSize() <= 0) {
				// 根据学校id和名字查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentByNameAndSchoolWithPage);
			return json;
		}
		// 仅学校
		if ((schoolId != null) && (name == null && gradeId == null && specialtyId == null && classGradeId == null
				&& collegeId == null)) {
			PageInfo<Student> queryStudentBySchoolWithPage;
			try {
				queryStudentBySchoolWithPage = studentService.queryStudentBySchoolWithPage(pageNum, pageSize, schoolId);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentBySchoolWithPage.getSize() <= 0) {
				// 根据学校id查询出来页为空，则返回2该页为空。
				json.put("status", 2);
				json.put("message", "该页暂时没有学生！");
				return json;
			}
			// 成功的操作
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentList", queryStudentBySchoolWithPage);
			return json;
		} else {
			json.put("status", 3);
			json.put("message", "参数类型不匹配！");
			return json;
		}
	}

	/**
	 * @describe 根据姓名模糊查询出学生有关信息
	 * @param name
	 * @return
	 */
	@RequestMapping(value = "/queryManyStudentByNameLike", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryManyStudentByNameLike(String name, int pageSize, int pageNum) {
		JSONObject json = new JSONObject();
		if (name == null || "".equals(name)) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		PageInfo<Student> queryOneStudentByNameLikeWithPage;
		try {
			queryOneStudentByNameLikeWithPage = studentService.queryManyStudentByNameLikeWithPage(pageNum, pageSize,
					name);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		if (queryOneStudentByNameLikeWithPage.getSize() <= 0) {
			json.put("status", 2);
			json.put("message", "暂无查询结果！");
			return json;
		}
		json.put("status", 0);
		json.put("message", "操作成功！");
		json.put("studentList", queryOneStudentByNameLikeWithPage);
		return json;
	}

	/**
	 * @describe 根据班级id查询该班级的所有学生集合然后分页显示
	 * @param classGradeId 需要查询的班级id
	 * @return
	 */
	@RequestMapping(value = "/queryStudentByClassGrade", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryStudentByClassGrade(int pageNum, int pageSize, String classGradeId) {
		// 参数校验
		JSONObject json = new JSONObject();
		if (classGradeId == null || "".equals(classGradeId)) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		// 根据班级id查询班级
		PageInfo<Student> queryOneClassGradeByClassGradeIdWithPage;
		try {
			queryOneClassGradeByClassGradeIdWithPage = studentService.queryClassGradeByClassGradeIdWithPage(pageNum,
					pageSize, classGradeId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误");
			return json;
		}
		if (queryOneClassGradeByClassGradeIdWithPage == null) {
			json.put("status", 2);
			json.put("message", "该班级不存在！");
			return json;
		}
		if (queryOneClassGradeByClassGradeIdWithPage.getSize() <= 0) {
			json.put("status", 3);
			json.put("message", "该页数数据为空！");
			return json;
		}
		json.put("status", 0);
		json.put("message", "操作成功！");
		json.put("studentList", queryOneClassGradeByClassGradeIdWithPage);
		return json;
	}

	/**
	 * @describe 根据年级id查询该年级的所有学生集合然后分页显示
	 * @param pageNum
	 * @param pageSize
	 * @param classGrade
	 * @return
	 */
	@RequestMapping(value = "/queryStudentByGrade", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryStudentByGrade(int pageNum, int pageSize, String gradeId) {
		// 参数校验
		JSONObject json = new JSONObject();
		if (gradeId == null || "".equals(gradeId)) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		// 查询年级是否存在
		Grade selcetOneGradeByGradeId;
		try {
			selcetOneGradeByGradeId = gradeMapper.selcetOneGradeByGradeId(gradeId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (selcetOneGradeByGradeId == null) {
			json.put("status", 2);
			json.put("message", "该年级不存在！");
			return json;
		}
		// 去查询学生
		PageInfo<Student> queryStudentByGradeWithPage;
		try {
			queryStudentByGradeWithPage = studentService.queryStudentByGradeWithPage(pageNum, pageSize, gradeId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (queryStudentByGradeWithPage.getSize() <= 0) {
			json.put("status", 3);
			json.put("message", "该页数数据为空！");
			return json;
		}
		// 返回查询结果
		json.put("status", 0);
		json.put("message", "操作成功！");
		json.put("studentList", queryStudentByGradeWithPage);
		return json;
	}

	/**
	 * @describe 根据专业id查询该专业的所有学生集合然后分页显示
	 * @param pageNum     第几页开始查询
	 * @param pageSize    一页显示的大小
	 * @param specialtyId 专业id
	 * @return
	 */
	@RequestMapping(value = "/queryStudentBySpecialty", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryStudentBySpecialty(int pageNum, int pageSize, String specialtyId) {
		// 参数校验
		JSONObject json = new JSONObject();
		if (specialtyId == null || "".equals(specialtyId)) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		// 查询专业是否存在
		Specialty selcetOneSpecialtyBySpecialtyId;
		try {
			selcetOneSpecialtyBySpecialtyId = specialtyMapper.selcetOneSpecialtyBySpecialtyId(specialtyId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (selcetOneSpecialtyBySpecialtyId == null) {
			json.put("status", 2);
			json.put("message", "该专业不存在！");
			return json;
		}
		// 查询
		PageInfo<Student> queryStudentBySpecialtyWithPage;
		try {
			queryStudentBySpecialtyWithPage = studentService.queryStudentBySpecialtyWithPage(pageNum, pageSize,
					specialtyId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (queryStudentBySpecialtyWithPage.getSize() <= 0) {
			json.put("status", 3);
			json.put("message", "该页数数据为空！");
			return json;
		}
		// 返回查询结果
		json.put("status", 0);
		json.put("message", "操作成功！");
		json.put("studentList", queryStudentBySpecialtyWithPage);
		return json;
	}

	/**
	 * @describe 根据学院id查询该学院的所有学生集合然后分页显示
	 * @param pageNum   第几页开始查询
	 * @param pageSize  一页显示的大小
	 * @param collegeId 学院id
	 * @return
	 */
	@RequestMapping(value = "/queryStudentByCollege", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryStudentByCollege(int pageNum, int pageSize, String collegeId) {
		JSONObject json = new JSONObject();
		// 数据校验
		if (collegeId == null || "".equals(collegeId)) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		// 查询该学院
		College selcetOneCollegeByCollegeId;
		try {
			selcetOneCollegeByCollegeId = collegeMapper.selcetOneCollegeByCollegeId(collegeId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (selcetOneCollegeByCollegeId == null) {
			json.put("status", 2);
			json.put("message", "该学院不存在！");
			return json;
		}
		// 进行查询
		PageInfo<Student> queryStudentByCollegeWithPage;
		try {
			queryStudentByCollegeWithPage = studentService.queryStudentByCollegeWithPage(pageNum, pageSize, collegeId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (queryStudentByCollegeWithPage.getSize() <= 0) {
			json.put("status", 3);
			json.put("message", "该页数数据为空！");
			return json;
		}
		json.put("status", 0);
		json.put("message", "操作成功！");
		json.put("studentList", queryStudentByCollegeWithPage);
		return json;
	}

	/**
	 * @describe 根据学校id查询该学校的所有学生集合然后分页显示
	 * @param pageNum  页号
	 * @param pageSize 一页显示多少数据
	 * @param schoolId 学校id
	 * @return
	 */
	@RequestMapping(value = "/queryStudentBySchool", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryStudentBySchool(int pageNum, int pageSize, String schoolId) {
		JSONObject json = new JSONObject();
		// 参数校验
		if (schoolId == null || "".equals(schoolId)) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		// 查询该学校
		School selcetOneSchool;
		try {
			selcetOneSchool = schoolMapper.selcetOneSchool(schoolId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (selcetOneSchool == null) {
			json.put("status", 2);
			json.put("message", "该学校不存在！");
			return json;
		}
		// 进行分页
		PageInfo<Student> queryStudentBySchoolWithPage;
		try {
			queryStudentBySchoolWithPage = studentService.queryStudentBySchoolWithPage(pageNum, pageSize, schoolId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (queryStudentBySchoolWithPage.getSize() <= 0) {
			json.put("status", 3);
			json.put("message", "该页数数据为空！");
			return json;
		}
		// 返回查询结果
		json.put("status", 0);
		json.put("message", "操作成功！");
		json.put("studentList", queryStudentBySchoolWithPage);
		return json;
	}

	/**
	 * @describe 根据公司id查询该公司的所有学生名字集合然后分页显示
	 * @param pageNum   页号
	 * @param pageSize  每页显示大小
	 * @param companyId 公司id
	 * @return
	 */
	@RequestMapping(value = "/queryStudentByCompany", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryStudentByCompany(Integer pageNum, Integer pageSize, String companyId) {
		JSONObject json = new JSONObject();
		if (pageNum == null || pageSize == null || companyId == null || "".equals(companyId)) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		Company queryCompanyByCompanyId;
		try {
			queryCompanyByCompanyId = companyMapper.queryCompanyByCompanyId(companyId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (queryCompanyByCompanyId == null) {
			json.put("status", 2);
			json.put("message", "该公司不存在！");
			return json;
		}
		PageInfo<Student> queryStudentByCompanyWithPage;
		try {
			queryStudentByCompanyWithPage = studentService.queryStudentByCompanyWithPage(pageNum, pageSize, companyId);
		} catch (Exception e) {
			e.printStackTrace();
			json.put("status", -1);
			json.put("message", "服务器内部错误！");
			return json;
		}
		if (queryStudentByCompanyWithPage.getSize() <= 0) {
			json.put("status", 3);
			json.put("message", "该页暂时没有学生！");
			return json;
		}
		// 返回查询结果
		json.put("status", 0);
		json.put("message", "操作成功！");
		json.put("studentList", queryStudentByCompanyWithPage);
		return json;
	}

	/**
	 * 
	 * @param pageNum  从第几页开始查询
	 * @param pageSize 页面大小
	 * @param tno      教师编号
	 * @param flag     =1查询实习集合 =0查询未实习人的集合
	 * @return
	 */
	@RequestMapping(value = "/queryStudentWithNoInternship", method = RequestMethod.GET)
	@ResponseBody
	public JSONObject queryStudentWithNoInternship(Integer pageNum, Integer pageSize, String tno, Integer flag) {
		JSONObject json = new JSONObject();
		// 数据校验
		if (pageNum == null || pageSize == null || tno == null || "".equals(tno) || flag == null) {
			json.put("status", 1);
			json.put("message", "传入参数不合法！");
			return json;
		}
		// 对flag进行判断:1查实习的人,0未实习的人
		if (flag == 1) {
			PageInfo<Student> queryStudentWithInternshipWithPage;
			try {
				queryStudentWithInternshipWithPage = studentService.queryStudentWithInternshipWithPage(pageNum,
						pageSize, tno);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentWithInternshipWithPage.getSize() <= 0) {
				json.put("status", 2);
				json.put("message", "该页没有学生！");
				return json;
			}
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentlist", queryStudentWithInternshipWithPage);
			return json;
		} else {// 0未实习的人
			PageInfo<Student> queryStudentWithNoInternshipWithPage;
			try {
				queryStudentWithNoInternshipWithPage = studentService.queryStudentWithNoInternshipWithPage(pageNum,
						pageSize, tno);
			} catch (Exception e) {
				e.printStackTrace();
				json.put("status", -1);
				json.put("message", "服务器内部错误！");
				return json;
			}
			if (queryStudentWithNoInternshipWithPage.getSize() <= 0) {
				json.put("status", 2);
				json.put("message", "该页没有学生！");
				return json;
			}
			json.put("status", 0);
			json.put("message", "操作成功！");
			json.put("studentlist", queryStudentWithNoInternshipWithPage);
			return json;
		}
	}

	@RequestMapping(value = "/downExcel", method = RequestMethod.GET)
	@ResponseBody
	public ResponseEntity<byte[]> downExcel(HttpServletRequest request) {
		// 获取文件
		File file = new File(request.getServletContext().getRealPath("/excel/excel_.xlsx"));
		String fileName = file.getName();
		// 对文件名编码，防止中文文件乱码
		try {
			fileName = FileUploadUtil.getFilename(request, fileName);
		} catch (Exception e1) {
			e1.printStackTrace();
			return null;
		}
//			fileName = new String(fileName.getBytes("utf-8"), "ISO8859-1");
		// 设置响应头
		HttpHeaders headers = new HttpHeaders();
		// 通知浏览器以下载的方式打开文件
		headers.setContentDispositionFormData("attachment", fileName);
		// 定义以二进制流的形式下载返回文件数据
		headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
		// 使用SringMVC的ResponseEntity对象封装返回下载数据,Commons FileUpload组件的FileUtils读取文件
		try {
			return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file), headers, HttpStatus.OK);
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}

	}

	@RequestMapping(value = "/exportStudent", method = RequestMethod.GET)
	@ResponseBody
	public ResponseEntity<byte[]> exportStudent(String tno, Integer flag,HttpServletRequest request) {
		// flag=0导出这个教师的未实习的人
		// flag=1导出这个教师的已实习的人
		if (tno == null || "".equals(tno) || flag == null) {
			return null;
		}
		if (flag == 1) {// flag=1导出这个教师的已实习的人
			List<Student> queryStudentWithInternship = studentMapper.queryStudentWithInternship(tno);
			if(queryStudentWithInternship.size()<=0) {
				return null;
			}
			String exportExcel = ExportExcelUtil.ExportExcel(queryStudentWithInternship, request);
			ResponseEntity<byte[]> download = FileDownUtil.download(request, exportExcel);
			try {
				Files.deleteIfExists(new File(exportExcel).toPath());
			} catch (IOException e) {
				e.printStackTrace();
			}
				return download;
		}else {// flag=0导出这个教师的未实习的人
			List<Student> queryStudentWithNoInternship = studentMapper.queryStudentWithNoInternship(tno);
			if(queryStudentWithNoInternship.size()<=0) {
				return null;
			}
			String exportExcel = ExportExcelUtil.ExportExcel(queryStudentWithNoInternship, request);
			ResponseEntity<byte[]> download = FileDownUtil.download(request, exportExcel);
			try {
				Files.deleteIfExists(new File(exportExcel).toPath());
			} catch (IOException e) {
				e.printStackTrace();
			}
				return download;
		}
	}
}